home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / aminet / dev / lang / bcpl4amiga.lha / bcpl / interp.c < prev    next >
C/C++ Source or Header  |  1991-02-05  |  4KB  |  250 lines
  1. #include    "icint.h"
  2.  
  3. int interpret()
  4. {
  5. #ifdef    cware
  6.     static int    a, b, c, d, w, p;
  7.     static word    *wp;
  8. #else
  9.     register int    a, b, c, d, w, p;
  10.     register word    *wp;
  11. #endif
  12. #ifdef    unix
  13.     register word    *rmem = mem;
  14. #define    mem    rmem
  15. #endif
  16.  
  17.     p = pp;
  18.     c = progvec;
  19.     cyclecount = 0;
  20. fetch:
  21.     cyclecount++;
  22.     w = mem[c++];
  23.  
  24.     if (w & DBIT)
  25.         d = mem[c++];
  26.     else
  27.         d = w & ABITS;
  28.  
  29. #ifdef    DEBUG
  30.     fprintf(stderr, "%04x: %04x %05d\n", c - progvec - 1, w, d);
  31. #endif    DEBUG
  32.  
  33.     if (w & PBIT)
  34.         d += p;
  35.     if (w & GBIT)
  36.         d += gp;
  37.     if (w & IBIT)
  38.         d = mem[d];
  39.  
  40. #ifdef    profiling
  41.     ++majinstr[(w >> FSHIFT) & 07];
  42. #endif
  43.  
  44.     switch ((w >> FSHIFT) & 07)
  45.     {
  46.     case OP_L:
  47.         b = a;
  48.         a = d;
  49.         goto fetch;
  50.  
  51.     case OP_S:
  52.         mem[d] = a;
  53.         goto fetch;
  54.  
  55.     case OP_A:
  56.         a += d;
  57.         goto fetch;
  58.  
  59.     case OP_J:
  60.         c = d;
  61.         goto fetch;
  62.  
  63.     case OP_T:
  64.         if (a)
  65.             c = d;
  66.         goto fetch;
  67.  
  68.     case OP_F:
  69.         if (!a)
  70.             c = d;
  71.         goto fetch;
  72.  
  73.     case OP_K:
  74.         d += p;
  75.         mem[d] = p;
  76.         mem[d+1] = c;
  77.         p = d;
  78.         c = a;
  79.         goto fetch;
  80.  
  81.     case OP_X:
  82. #ifdef    profiling
  83.         ++mininstr[d];
  84. #endif
  85.         switch (d)
  86.         {
  87.         case 0:
  88.         default:
  89.  
  90.             fprintf(stderr, "Bad minor opcode %d at %d\n",
  91.                 d, c - progvec - 1);
  92.             return (-1);
  93.  
  94.         case 1:
  95.             a = mem[a];
  96.             goto fetch;
  97.         case 2:
  98.             a = -a;
  99.             goto fetch;
  100.         case 3:
  101.             a = ~a;
  102.             goto fetch;
  103.         case 4:
  104.             c = mem[p+1];
  105.             p = mem[p];
  106.             goto fetch;
  107.         case 5:
  108.             a *= b;
  109.             goto fetch;
  110.         case 6:
  111.             a = b / a;
  112.             goto fetch;
  113.         case 7:
  114.             a = b % a;
  115.             goto fetch;
  116.         case 8:
  117.             a += b;
  118.             goto fetch;
  119.         case 9:
  120.             a = b - a;
  121.             goto fetch;
  122.         case 10:
  123.             a = b == a ? ~0 : 0;
  124.             goto fetch;
  125.         case 11:
  126.             a = b != a ? ~0 : 0;
  127.             goto fetch;
  128.         case 12:
  129.             a = b < a ? ~0 : 0;
  130.             goto fetch;
  131.         case 13:
  132.             a = b >= a ? ~0 : 0;
  133.             goto fetch;
  134.         case 14:
  135.             a = b > a ? ~0 : 0;
  136.             goto fetch;
  137.         case 15:
  138.             a = b <= a ? ~0 : 0;
  139.             goto fetch;
  140.         case 16:
  141.             a = b << a;
  142.             goto fetch;
  143.         case 17:
  144.             a = b >> a;
  145.             goto fetch;
  146.         case 18:
  147.             a &= b;
  148.             goto fetch;
  149.         case 19:
  150.             a |= b;
  151.             goto fetch;
  152.         case 20:
  153.             a ^= b;
  154.             goto fetch;
  155.         case 21:
  156.             a ^= ~b;
  157.             goto fetch;
  158.  
  159.         case 22:
  160.             return (0);         /* finish */
  161.  
  162.         case 23:
  163.             wp = &mem[c];
  164.             b = *wp++;
  165.             d = *wp++;    /* switchon */
  166.             while (b-- != 0)
  167.             {
  168.                 if (a == *wp++)
  169.                 {
  170.                     c = *wp++;
  171.                     goto fetch;
  172.                 }
  173.                 wp++;
  174.             }
  175.             c = d;
  176.             goto fetch;
  177.  
  178. /*
  179. // cases 24 upwards are only called from the following
  180. // hand written intcode library - iclib:
  181.  
  182. //    11 lip2 x24 x4 g11l11 /selectinput
  183. //    12 lip2 x25 x4 g12l12 /selectoutput
  184. //    13 x26 x4      g13l13 /rdch
  185. //    14 lip2 x27 x4 g14l14 /wrch
  186. //    42 lip2 x28 x4 g42l42 /findinput
  187. //    41 lip2 x29 x4 g41l41 /findoutput
  188. //    30 lip2 x30 x4 g30l30 /stop
  189. //    31 x31 x4 g31l31 /level
  190. //    32 lip3 lip2 x32 g32l32 /longjump
  191. //    46 x33 x4 g46l46 /endread
  192. //    47 x34 x4 g47l47 /endwrite
  193. //    40 lip3 lip2 x35 g40l40 /aptovec
  194. //    85 lip3 lip2 x36 x4 g85l85 / getbyte
  195. //    86 lip3 lip2 x37 x4 g86l86 / putbyte
  196. //    z
  197. */
  198.  
  199.         case 24:
  200.             slctinput(a);
  201.             goto fetch;
  202.         case 25:
  203.             slctoutput(a);
  204.             goto fetch;
  205.         case 26:
  206.             a = rdch();
  207.             goto fetch;
  208.         case 27:
  209.             wrch(a);
  210.             goto fetch;
  211.         case 28:
  212.             a = findinput(a);
  213.             goto fetch;
  214.         case 29:
  215.             a = findoutput(a);
  216.             goto fetch;
  217.         case 30:
  218.             return (a);        /* stop(a) */
  219.         case 31:
  220.             a = mem[p];
  221.             goto fetch;        /* used in level() */
  222.         case 32:
  223.             p = a;
  224.             c = b;            /* used in longjump(p,l) */
  225.             goto fetch;
  226.         case 33:
  227.             endread();
  228.             goto fetch;
  229.         case 34:
  230.             endwrite();
  231.             goto fetch;
  232.         case 35:
  233.             d = p+b+1;        /* used in aptovec(f, n) */
  234.             mem[d] = mem[p];
  235.             mem[d+1] = mem[p+1];
  236.             mem[d+2] = p;
  237.             mem[d+3] = b;
  238.             p = d;
  239.             c = a;
  240.             goto fetch;
  241.         case 36:
  242.             a = icgetbyte(a, b);    /* getbyte(s, i) */
  243.             goto fetch;
  244.         case 37:
  245.             icputbyte(a, b, mem[p+4]);    /* putbyte(s, i, ch) */
  246.             goto fetch;
  247.         }
  248.     }
  249. }
  250.